package com.ffggffgfv.backend.controller;

import com.ffggffgfv.backend.dto.PageResult;
import com.ffggffgfv.backend.dto.RoleDTO;
import com.ffggffgfv.backend.dto.RolePermissionDTO;
import com.ffggffgfv.backend.entity.Permission;
import com.ffggffgfv.backend.entity.Role;
import com.ffggffgfv.backend.service.RoleService;
import com.ffggffgfv.backend.util.JWTUtil;
import com.ffggffgfv.backend.util.Result;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 角色控制器
 */
@RestController
@RequestMapping("/api/roles")
public class RoleController {

    @Autowired
    private RoleService roleService;

    @Autowired
    private JWTUtil jwtUtil;

    /**
     * 获取角色列表（分页）
     *
     * @param name     角色名称（可选）
     * @param pageNum  页码（默认1）
     * @param pageSize 每页数量（默认10）
     * @param token    JWT令牌
     * @return 角色列表
     */
    @GetMapping
    public Result getRoles(
            @RequestParam(required = false) String name,
            @RequestParam(required = false, defaultValue = "1") Integer pageNum,
            @RequestParam(required = false, defaultValue = "10") Integer pageSize,
            @RequestHeader("Authorization") String token) {

        // 权限验证
        if (!validateAdminPermission(token)) {
            return Result.forbidden("无权访问");
        }

        PageResult<Role> pageResult = roleService.findByPage(name, pageNum, pageSize);
        return Result.success(pageResult, "共" + pageResult.getTotal() + "条记录");
    }

    /**
     * 创建角色
     *
     * @param roleDTO 角色DTO
     * @param token   JWT令牌
     * @return 创建结果
     */
    @PostMapping
    public Result createRole(@RequestBody RoleDTO roleDTO, @RequestHeader("Authorization") String token) {
        // 权限验证（仅超级管理员）
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权创建角色");
        }

        // 参数校验
        if (roleDTO.getName() == null || roleDTO.getName().trim().isEmpty()) {
            return Result.validateFailed("角色名称不能为空");
        }
        if (roleDTO.getCode() == null || roleDTO.getCode().trim().isEmpty()) {
            return Result.validateFailed("角色编码不能为空");
        }

        // 检查编码是否已存在
        if (roleService.isCodeExists(roleDTO.getCode())) {
            return Result.conflict("角色编码已存在");
        }

        // 创建角色
        Role role = new Role();
        BeanUtils.copyProperties(roleDTO, role);
        Role createdRole = roleService.createRole(role);

        return Result.success(createdRole, "角色创建成功");
    }

    /**
     * 更新角色信息
     *
     * @param id      角色ID
     * @param roleDTO 角色DTO
     * @param token   JWT令牌
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public Result updateRole(
            @PathVariable Long id,
            @RequestBody RoleDTO roleDTO,
            @RequestHeader("Authorization") String token) {

        // 权限验证（仅超级管理员）
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权更新角色");
        }

        // 查询角色是否存在
        Role existingRole = roleService.findById(id);
        if (existingRole == null) {
            return Result.validateFailed("角色不存在");
        }

        // 创建角色对象
        Role role = new Role();
        BeanUtils.copyProperties(roleDTO, role);
        role.setId(id);

        // 更新角色
        Role updatedRole = roleService.updateRole(id, role);
        if (updatedRole == null) {
            return Result.validateFailed("更新失败");
        }

        return Result.success(updatedRole, "角色更新成功");
    }

    /**
     * 分配角色权限
     *
     * @param roleId            角色ID
     * @param rolePermissionDTO 权限ID列表DTO
     * @param token             JWT令牌
     * @return 分配结果
     */
    @PostMapping("/{roleId}/permissions")
    public Result assignPermissions(
            @PathVariable Long roleId,
            @RequestBody RolePermissionDTO rolePermissionDTO,
            @RequestHeader("Authorization") String token) {

        // 权限验证（仅超级管理员）
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权分配角色权限");
        }

        // 查询角色是否存在
        Role existingRole = roleService.findById(roleId);
        if (existingRole == null) {
            return Result.validateFailed("角色不存在");
        }

        // 分配权限
        boolean result = roleService.assignPermissions(roleId, rolePermissionDTO);
        if (result) {
            Map<String, Object> data = new HashMap<>();
            data.put("roleId", roleId);
            data.put("permissionCount", rolePermissionDTO.getPermissionIds() != null ?
                    rolePermissionDTO.getPermissionIds().size() : 0);
            return Result.success(data, "权限分配成功");
        } else {
            return Result.validateFailed("权限分配失败");
        }
    }

    /**
     * 获取角色权限
     *
     * @param roleId 角色ID
     * @param token  JWT令牌
     * @return 角色权限列表
     */
    @GetMapping("/{roleId}/permissions")
    public Result getRolePermissions(@PathVariable Long roleId, @RequestHeader("Authorization") String token) {
        // 权限验证
        if (!validateAdminPermission(token)) {
            return Result.forbidden("无权访问");
        }

        // 查询角色是否存在
        Role existingRole = roleService.findById(roleId);
        if (existingRole == null) {
            return Result.validateFailed("角色不存在");
        }

        // 获取角色权限
        List<Permission> permissions = roleService.getPermissions(roleId);
        return Result.success(permissions, "获取角色权限成功");
    }

    /**
     * 验证是否具有管理员权限
     *
     * @param token JWT令牌
     * @return 是否有管理员权限
     */
    private boolean validateAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                return jwtUtil.hasAdminRole(token);
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 验证是否具有超级管理员权限
     *
     * @param token JWT令牌
     * @return 是否有超级管理员权限
     */
    private boolean validateSuperAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                // 在实际项目中，应该根据角色编码判断是否为超级管理员
                // 这里简化处理，假设有ROLE_SUPER_ADMIN角色
                List<String> roles = jwtUtil.extractClaim(token, claims -> {
                    return claims.get("roles", List.class);
                });
                return roles != null && roles.contains("ROLE_SUPER_ADMIN");
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }
}
